Time Management Project Final Report

Author

Hunter Smith

Published

December 1, 2025

Description

This project aims to help individuals effectively manage their time by providing an intuitive platform for scheduling tasks and events. Users will be able to organize their day, prioritize activities, and visualize their schedule in a clear, structured way. By simplifying the process of planning and tracking commitments, the application promotes better productivity and time management. Our goal is to offer a user-friendly tool that encourages individuals to stay on top of their personal and professional responsibilities.

Users

Users will interface with the website by creating multiple profiles. All Users will be able to see the tasks, Goals, and Projects of other Users, but that is by design to encourage accountability and productivity amongst groups who are using this application.

Users will be able to view their tasks, goals, and projects through the various links in the website to those specific entities. In those sections Users will be able to update, delete, and create records as well.

We wanted Users to feel like they were part of something greater when working on projects which is part of the reason for many of these design choices.

Entity Relationship Diagram

erDiagram 

   User{
    int userID PK
    string first_name
    string last_name
   }
   Calendar{
    int userID FK
    int capacity
   }
   Task{
    int taskID PK
    int userID FK
    int goalID FK
    int projectID FK
    String task_name
    int start
    int end
    enum priority
    boolean is_complete
   }
   Project{
    int projectID PK
    int userID FK
    String project_name
    int start
    int end
    enum priority
    boolean is_complete
   }
   Goal{
    int goalID PK
    int userID FK
    String goal_name
    int capacity
    enum priority
    boolean is_complete
   }


    User ||--|| Calendar : has
    Calendar ||--o{ Task : contains
    Calendar ||--o{ Project : contains
    Calendar ||--o{ Goal : contains
    Goal ||--|{ Task : contains
    Project ||--|{ Task : contains

erDiagram 

   User{
    int userID PK
    string first_name
    string last_name
   }
   Calendar{
    int userID FK
    int capacity
   }
   Task{
    int taskID PK
    int userID FK
    int goalID FK
    int projectID FK
    String task_name
    int start
    int end
    enum priority
    boolean is_complete
   }
   Project{
    int projectID PK
    int userID FK
    String project_name
    int start
    int end
    enum priority
    boolean is_complete
   }
   Goal{
    int goalID PK
    int userID FK
    String goal_name
    int capacity
    enum priority
    boolean is_complete
   }


    User ||--|| Calendar : has
    Calendar ||--o{ Task : contains
    Calendar ||--o{ Project : contains
    Calendar ||--o{ Goal : contains
    Goal ||--|{ Task : contains
    Project ||--|{ Task : contains
   




DB Integrity

In this database design, integrity is maintained by ensuring that the data is consistent and valid. Here’s how it’s done:

Relationships Between Tables: The tables are connected through “foreign keys.” For example, each task is linked to a user and a project. If a user is deleted, all tasks, goals, and projects linked to that user are also deleted automatically. This prevents orphaned data (data without a parent).

Unique Identifiers: Each table has a “primary key” (like userID or taskID) that uniquely identifies each record. This helps prevent duplicate data and ensures each record can be found easily.

Data Types: The right types of data are used for each field, like numbers for IDs and dates for start and end times. This ensures data is stored properly and only the correct type of data is allowed (e.g., no text where a number should be).

Required Data: Some fields can’t be left empty, like userID in the Task table. This ensures that every record has the necessary information to make sense.

Avoiding Redundancy: Instead of repeating information, the database splits it into separate tables. For example, user information is stored in one table, and each task or project is linked to a user through their userID. This reduces repeated data and makes it easier to update.

Order of Deletions: The database ensures that when a table is dropped or recreated, dependent tables are handled first, so nothing breaks due to the relationships between tables.

In short, this setup keeps the data connected, organized, and consistent by using rules for how tables relate and ensuring only valid data is entered.

Data and the DDL

Appropriate data was inserted into each table for testing purposes.

User Interface design

Overall Design Philosophy

Simplicity and Clarity: Each section of the UI is designed to address one specific task—creating, updating, deleting, or entities ensuring that the user can focus on one operation at a time.

Consistency: The use of dropdowns, text fields, and buttons is consistent across forms, which helps reduce cognitive load and makes the UI easier to navigate.

Accessibility: The forms are designed with clear labels for each input field and logical groupings of related elements. This makes it easier for users to understand the actions they are performing and reduces the chance of errors.

Real-time Data Display: The tables and dropdowns show real-time data directly fetched from the database, providing a seamless user experience.

The design’s key focus is to be functional, efficient, and user-friendly while ensuring the database constraints and logic are enforced without being intrusive in the interface.

CRUD Operations overview

In this section we will be demonstrating that our website for our database can perform CRUD operations. Below is a picture that describes the goals entity and the following operations that can be done on the goals entity to demonstrate functionality.

Also it’s important to note that although we are demonstrating the functionality of the Goals entity in this portion of the report, the tasks and projects entities have very similar functionality.

Goals Entity

In this picture all the essential CRUD operations are featured, but I will talk about them in more detail in the sections below –>

Create

Goals Create

In the picture above an individual can select a User add a Goal to that User and specify the certain fields related to that Goal. This shows that you can Create records as specified in the C of CRUD.

Retrieve

Goals Retrieve

In the picture above we can see all the goals for all the User listed. This demonstrates that records can be retrieved from the database and displayed to the User per the R in CRUD.

Update

Goals Update

In this picture above an individual can change all the fields related to a Goal and those changes will cascade down to the task as specified in the DDL. This demonstrates that a user can update a record per the U in CRUD.

Delete

Goals Delete

In the picture above a user can delete a Goal for themselves or other users. This demonstrates the D in CRUD. Also the changes will cascade down to related entities for this operation as well.